{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "03b355bb-6442-41c9-abca-6df8af26f92e",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Exploring Model Extensibility for Named Entity Recognition: A Case Study on Catastrophic Incidents"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdb7e355-7e77-4cdc-bab7-782bc12a5a7b",
   "metadata": {},
   "source": [
    "## Table of Contents"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3bae851-4b50-437b-a193-b428626e5189",
   "metadata": {},
   "source": [
    "* [Introduction](#introduction)\n",
    "* [Imports](#imports)\n",
    "* [Prompt Engineering](#prompt-engineering)\n",
    "* [Esri Model Definition(EMD) file](#esri-model-definition-emd-file)\n",
    "* [Anatomy of the Extension Function](#anatomy-of-the-extension-function)\n",
    "  * [Define the ```__init__``` function](#define-the-__init__-function)\n",
    "  * [Define the ```getParameterInfo``` function](#define-the-getparameterinfo-function)\n",
    "  * [Define the ```initialize``` function](#define-initialize-function)\n",
    "  * [Define the ```getConfiguration``` function](#define-the-getconfiguration-function)\n",
    "  * [Define the ```predict``` function](#define-the-predict-function)\n",
    "* [Complete NLP Function](#complete-nlp-function)\n",
    "* [Create Custom ESRI Deep Learning Package (.dlpk) file](#custom-deep-learning-package-model-file)\n",
    "* [ESRI Deep Learning Package (.dlpk) file in arcgis.learn API](#using-the-custom-esri-deep-learning-package-dlpk-file-with-the-arcgislearn-api)\n",
    "* [Tool Interface](#tool-interface)\n",
    "* [Sample Input Table](#sample-input-table)\n",
    "* [Sample Output Table](#sample-output-table)\n",
    "* [Conclusion](#conclusion)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8f2019f-27f2-4fb2-90be-e057cb33bddf",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fca1d4c6-a563-456d-a1e9-556cc61cd751",
   "metadata": {},
   "source": [
    "The **GeoAI toolbox** features a comprehensive **Text Analysis toolset** designed for diverse text processing tasks, including _text classification, entity extraction, and text transformation_. Leveraging advanced natural language processing (NLP) models built on powerful backbones like BERT, RoBERTa, T5, and large language models (LLMs) such as Mistral, these tools deliver high-performance text analysis.\n",
    "\n",
    "But what if you encounter a **Text model**, like a **BERT** or **T5** backbone-based language model, or a **large language model (LLM)** such as **LLaMA**, **Claude**, or **Mistral**, that isn’t included in the current learning module? Perhaps you want to utilize it from a library or an open-source code repository. Or maybe you’ve fine-tuned your own **text model** for specific tasks, such as standardizing addresses, conducting sentiment analysis, or extracting custom entities or relationships not currently supported by the Text Analysis toolset. How can you implement this within **ArcGIS Pro**?\n",
    "\n",
    "To address these needs, ArcGIS allows for the integration of external third-party language models, including both open-source LLMs and commercial LLMs accessed via web APIs. Please note that if you use a web-hosted LLM, the data processed will be sent to the LLM provider. Python developers can create custom NLP functions to interface with these external models, packaging their models as ESRI Deep Learning Package (.dlpk) file for use with the following tools:\n",
    "\n",
    "1. [Classify Text Using Deep Learning (GeoAI)](https://pro.arcgis.com/en/pro-app/latest/tool-reference/geoai/classify-text-using-deep-learning.htm)\n",
    "2. [Extract Entities Using Deep Learning (GeoAI)](https://pro.arcgis.com/en/pro-app/latest/tool-reference/geoai/extract-entities-using-deep-learning.htm)\n",
    "3. [Transform Text Using Deep Learning (GeoAI)](https://pro.arcgis.com/en/pro-app/latest/tool-reference/geoai/transform-text-using-deep-learning.htm)\n",
    "\n",
    "The **ESRI Deep Learning Package (.dlpk)** file of the custom NLP function is also supported through the `arcgis.learn` Python API, which accommodates third-party custom models via various classes, including `TextClassifier`, `EntityRecognizer`, and `SequenceToSequence`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e23ad82-0f0e-49c0-824d-c337b986cc40",
   "metadata": {},
   "source": [
    "**Named Entity Recognition (NER)** is a vital element of text analysis, designed to automatically identify and categorize entities within text, including people, locations, organizations, dates, and more, depending on the context. By extracting these entities, NER transforms unstructured data into a structured format, facilitating efficient analysis of large datasets. This is particularly beneficial in domain-specific scenarios, such as climate-related disasters, where NER can pinpoint crucial attributes like the type of event, affected locations, extent of damage, and impacted populations. Such capabilities enhance data organization, accelerate insights, and improve decision-making for analysis, reporting, and forecasting.\n",
    "\n",
    "This work aims to showcase the functionality of the **Model Extension** for extracting named entities using a pre-trained model in a zero-shot setting. We will investigate a use case in which a summary of a catastrophic event is provided, focusing on the extraction of key entities such as the affected location, extent of damage, type of event, and date.\n",
    "\n",
    "#### Intended Audience\n",
    "- Analysts\n",
    "- Extension model developers\n",
    "\n",
    "#### Dataset\n",
    "- [Billion-dollar disaster events](https://www.ncei.noaa.gov/access/billions/state-summary/US)\n",
    "\n",
    "#### Capability Demonstration\n",
    "- Out-of-the-box use of pre-trained model\n",
    "- Minimal or no annotation required\n",
    "- Comparable accuracy\n",
    "- Integration of custom models within the ArcGIS Pro **Extract Entities Using Deep Learning (GeoAI)** and API\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4717d97d-9799-45fe-9c0d-6389a28b296c",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baf8af26-a354-4e7e-9432-5e06c2963ce3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import json\n",
    "from arcgis.features import FeatureSet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3fe353c-80d7-4ae8-8068-a5a5be464160",
   "metadata": {},
   "source": [
    "## ESRI Model Definition (.emd) file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43b3734d-5e46-430b-8a49-6ea0869da80f",
   "metadata": {},
   "source": [
    "The ESRI Model Definition (.emd) file will contain both required and optional keys to ensure model execution. To run a extract entity model, we must provide the following essential keys:\n",
    "\n",
    "1. **InferenceFunction**: This key specifies the name of the module that defines the NLP function.\n",
    "2. **ModelType**: This key indicates the type of task. For the **Extract Entities Using Deep Learning (GeoAI)** tool, the value will be `Transformer`.\n",
    "3. **ArcGISLearnVersion**: NLP functions are supported in `arcgis.learn` from version 2.4.0 onward. This parameter is used to exclude older `.dlpk` files that have unsupported NLP functions.\n",
    "\n",
    "Additional keys can be defined at the discretion of the model extension author. In this instance, we have included the pre-trained model name under the key **PretrainedModel**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f9f51ea-e243-4005-96e3-5d317b060c11",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "{\n",
    "    \"InferenceFunction\": \"MyCustomNER.py\",\n",
    "    \"PretrainedModel\": \"urchade/gliner_large-v2.1\",\n",
    "    \"ModelType\": \"Transformer\",\n",
    "    \"ModelName\": \"_TransformerEntityRecognizer\",\n",
    "    \"ArcGISLearnVersion\": \"2.4.0\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c56a2c8-fc14-4b77-ae67-3611f01345c1",
   "metadata": {},
   "source": [
    "## Anatomy of the Extension Function "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13dfe383-1507-4f73-a64f-5b50aa3e5536",
   "metadata": {},
   "source": [
    "The model extension requires the process be wrapped in a class that implements the following functions:\n",
    "\n",
    "- `__init__`\n",
    "\n",
    "- `getParameterInfo`\n",
    "\n",
    "- `initialize`\n",
    "\n",
    "- `getConfiguration`\n",
    "\n",
    "- `predict`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db136602-a2e5-4e62-a942-073acea748fe",
   "metadata": {},
   "source": [
    "Let's create a custom extension model to extract the following information:\n",
    "\n",
    "- Impacted location\n",
    "- Event date\n",
    "- Quantity\n",
    "- Property damage\n",
    "- Climatic catastrophic event\n",
    "\n",
    "To achieve this, we'll utilize the pre-trained Named Entity Recognition (NER) model from [GLiNER](https://github.com/urchade/GLiNER). We'll input the relevant text along with the specified entities we wish to extract. For our purposes, we'll focus on the entities listed above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cb92a5c-60f2-4a7a-ab56-090010745357",
   "metadata": {},
   "source": [
    "### Define the ```__init__``` function "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fb5c83c",
   "metadata": {},
   "source": [
    "The `__init__` method initializes instance variables such as `name`, `description`, and other attributes essential for the NLP function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44842f46-01ac-47e4-aaeb-8a8d343e3a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "def __init__(self, **kwargs):\n",
    "    self.name = \"My Custom entity extractor\"\n",
    "    self.description = \"Pre-trained model based extension function\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6454a545-677c-40ea-bc49-400c1c854f88",
   "metadata": {},
   "source": [
    "### Define the ```getParameterInfo``` function "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c20706a-296c-4921-8043-230cb2078f8b",
   "metadata": {},
   "source": [
    "This function is designed to collect parameters from the user through Extract Entities Using Deep Learning (GeoAI). For our use case, it will gather the name of the **entity** to be extracted from the input text. The default value will be a comma-separated string of the aforementioned classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3e83278-ff8f-4bce-a92a-d33e4e0c36f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getParameterInfo(self):\n",
    "    t =  [{\n",
    "        \"name\": \"classes\",\n",
    "        \"dataType\": \"string\",\n",
    "        \"required\": False,\n",
    "        \"displayName\": \"name to classes\",\n",
    "        \"description\": \"A comma separated string of class names\",\n",
    "        \"value\": 'impacted location,event date,quantity,property damage,climatic catastropic event'\n",
    "\n",
    "    }]\n",
    "    return t\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce0936f8-cba5-4ad7-b685-0a89404514c5",
   "metadata": {},
   "source": [
    "### Define ```initialize``` function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a762da7-49c0-4e27-8618-25fab4883809",
   "metadata": {},
   "source": [
    "The `initialize` function acts as the central hub for the extension. Within this function, we will set up the necessary variables. It accepts two parameters via `kwargs`:\n",
    "\n",
    "#### Parameters in `kwargs`\n",
    "- **`model`**: The path to the ESRI Model Definition (.emd) file.\n",
    "- **`device`**: The name of the device (either GPU or CPU), which is particularly important for on-premises models.\n",
    "\n",
    "Unlike the `__init__` method, which creates an instance of the NLP function, `initialize` reads the ESRI Model Definition (.emd) file and configures the essential variables needed for inference."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b0ff33f-e9d6-496b-a72f-e366e1fffdc5",
   "metadata": {},
   "source": [
    "[GLiNER](https://github.com/urchade/GLiNER) is a Named Entity Recognition (NER) model that can identify any entity type using a bidirectional transformer encoder (similar to BERT). For deep learning functionality in ArcGIS Pro, supported deep learning framework libraries must be installed. The [Deep-learning-essentials](https://github.com/esri/deep-learning-frameworks) package provides a collection of essential packages for working with deep learning models and ArcGIS Pro. However, GLiNER is not included in Deep-learning-essentials, so we’ll use its repository to import the necessary classes and load the pre-trained model. Additionally, we will add placeholders for the specific classes to be extracted. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a249206e-aac3-460c-9d45-0b2a890f1bdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize(self, **kwargs):\n",
    "    with open(kwargs[\"model\"]) as f:\n",
    "        emd = json.load(f)\n",
    "    model_name = emd[\"PretrainedModel\"]\n",
    "    sys.path.append(os.path.dirname(__file__))\n",
    "    from GLiNER.gliner import GLiNER\n",
    "    self.model = GLiNER.from_pretrained(model_name)\n",
    "    self.considerd_class = kwargs.get(\"classes\", considered_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cec6fded-7ecc-4153-b844-06bb550cea0a",
   "metadata": {},
   "source": [
    "### Define the ```getConfiguration``` function "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10d0dfe3-1e73-4785-8c1a-b20657fb4536",
   "metadata": {},
   "source": [
    "This function receives `kwargs`, which contain parameter names and values collected from the user. Additionally, it will also contain parameters such as `batch_size`, which will control the tool's behavior. The **Extract Entities Using Deep Learning (GeoAI)** tool supports customization of `batch_size` and `address_tag`. The `batch_size` parameter determines how many records will be sent to the tool in a single batch, while `address_tag` specifies which entities will be geocoded.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c30dcea-b256-4857-8897-27845b42ffcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getConfiguration(self, **kwargs):\n",
    "    # Edit the batch size. Parameters to control the behaviour of the tool and post-process by the tool\n",
    "    if kwargs[\"batch_size\"] > 4:\n",
    "        kwargs[\"batch_size\"] = 4\n",
    "    self.max_token = kwargs.get(\"max_token\", 1024)\n",
    "    try:\n",
    "        self.max_token = float(self.max_token)\n",
    "        if self.max_token > 1024:\n",
    "            self.max_token = 512\n",
    "    except:\n",
    "        self.max_token = 512\n",
    "    kwargs[\"address_tag\"] = \"impacted location\"\n",
    "    self.considerd_class = kwargs.get(\"classes\", \"\").split(\",\")\n",
    "    return kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1db12cf3-8068-49df-b2cd-e87c2a531524",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Define the ```predict``` function "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69e64792-a095-4b57-a72a-031c278f5dd5",
   "metadata": {},
   "source": [
    "This function serves as the entry point for performing inference on the input. It takes a `FeatureSet` as input along with the field name that contains the relevant data. First, we will retrieve the field name from the provided `kwargs` and use it to extract the list of sentences for inference.\n",
    "\n",
    "In the next step, we will extract the input text for inference. The predicted output will be mapped to the corresponding class. Then, we will create a `FeatureSet` from the model's output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2e38656-36a7-474b-abb0-c9f5433d98d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(self, feature_set, **kwargs):\n",
    "    input_field = kwargs.get(\"input_field\", \"input_str\")\n",
    "    text_list = feature_set.df[input_field].to_list()\n",
    "    # text_list = feature_set\n",
    "\n",
    "    self.model = self.model.to('cuda')\n",
    "    all_data = []\n",
    "    features_list = []\n",
    "    for text in text_list:\n",
    "        temp_dict = {}\n",
    "        for i in self.considerd_class:\n",
    "            temp_dict[i] = [] \n",
    "\n",
    "        # Perform entity prediction\n",
    "        entities = self.model.predict_entities(text, self.considerd_class, threshold=0.5)\n",
    "\n",
    "        # Display predicted entities and their labels\n",
    "        for entity in entities:\n",
    "            # print(entity)\n",
    "            temp_dict[entity[\"label\"]] += [entity[\"text\"]]\n",
    "        for k,v in temp_dict.items():\n",
    "            temp_dict[k] = ','.join(v)\n",
    "        all_data.append(temp_dict)\n",
    "        temp_dict[\"input_str\"] = text\n",
    "        features_list.append({'attributes':temp_dict})  \n",
    "\n",
    "    field_class = []\n",
    "    for i in self.considerd_class:\n",
    "        field_class.append({\"name\": i, \"type\": \"esriFieldTypeString\"})\n",
    "    field_class.append({\"name\": \"input_str\", \"type\": \"esriFieldTypeString\"})\n",
    "    feature_dict = {\n",
    "        \"fields\": field_class,\n",
    "        'geometryType': \"\",\n",
    "        'features':features_list\n",
    "    }\n",
    "    return FeatureSet.from_dict(feature_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f812c3-1305-4007-94a5-5c2258e98a4c",
   "metadata": {},
   "source": [
    "Finally, the tool will receive a `FeatureSet` as output from the extensible function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1ef4c31-2ad8-472b-84a9-7ac95333e8c3",
   "metadata": {},
   "source": [
    "## Complete NLP Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0569e94-96fb-447f-b10e-6a595aa6d844",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import json\n",
    "from arcgis.features import FeatureSet\n",
    "\n",
    " \n",
    "considered_classes =[\"impacted location\", \"event date\", \"Quantity\", \"property damage\", \"climatic catastropic event\"]\n",
    "class MyCustomNER:\n",
    "    def __init__(self, **kwargs):\n",
    "        self.name = \"My Custom entity extractor\"\n",
    "        self.description = \"Pre-trained model based extension function\"\n",
    "\n",
    "    def initialize(self, **kwargs):\n",
    "        with open(kwargs[\"model\"]) as f:\n",
    "            emd = json.load(f)\n",
    "        model_name = emd[\"PretrainedModel\"]\n",
    "        sys.path.append(os.path.dirname(__file__))\n",
    "        from GLiNER.gliner import GLiNER\n",
    "        self.model = GLiNER.from_pretrained(model_name)\n",
    "        self.considerd_class = kwargs.get(\"classes\", considered_classes)\n",
    "\n",
    "    \n",
    "    def getConfiguration(self, **kwargs):\n",
    "        # Edit the batch size. Parameters to control the behaviour of the tool and post-process by the tool\n",
    "        if kwargs[\"batch_size\"] > 4:\n",
    "            kwargs[\"batch_size\"] = 4\n",
    "        self.max_token = kwargs.get(\"max_token\", 1024)\n",
    "        try:\n",
    "            self.max_token = float(self.max_token)\n",
    "            if self.max_token > 1024:\n",
    "                self.max_token = 512\n",
    "        except:\n",
    "            self.max_token = 512\n",
    "        kwargs[\"address_tag\"] = \"impacted location\"\n",
    "        self.considerd_class = kwargs.get(\"classes\", \"\").split(\",\")\n",
    "        return kwargs\n",
    "    \n",
    "    def getParameterInfo(self):\n",
    "        t =  [{\n",
    "            \"name\": \"classes\",\n",
    "            \"dataType\": \"integer\",\n",
    "            \"required\": False,\n",
    "            \"displayName\": \"name to classes\",\n",
    "            \"description\": \"A comma separated string of class names\",\n",
    "            \"value\": 'impacted location,event date,Quantity,property damage,climatic catastropic event'\n",
    "\n",
    "        }]\n",
    "        return t\n",
    "    \n",
    "    def predict(self, feature_set, **kwargs):\n",
    "        input_field = kwargs.get(\"input_field\", \"input_str\")\n",
    "        text_list = feature_set.df[input_field].to_list()\n",
    "        # text_list = feature_set\n",
    "\n",
    "        self.model = self.model.to('cuda')\n",
    "        all_data = []\n",
    "        features_list = []\n",
    "        for text in text_list:\n",
    "            temp_dict = {}\n",
    "            for i in self.considerd_class:\n",
    "                temp_dict[i] = [] \n",
    "\n",
    "            # Perform entity prediction\n",
    "            entities = self.model.predict_entities(text, self.considerd_class, threshold=0.5)\n",
    "\n",
    "            # Display predicted entities and their labels\n",
    "            for entity in entities:\n",
    "                # print(entity)\n",
    "                temp_dict[entity[\"label\"]] += [entity[\"text\"]]\n",
    "            for k,v in temp_dict.items():\n",
    "                temp_dict[k] = ','.join(v)\n",
    "            all_data.append(temp_dict)\n",
    "            temp_dict[\"input_str\"] = text\n",
    "            features_list.append({'attributes':temp_dict})  \n",
    "\n",
    "        field_class = []\n",
    "        for i in self.considerd_class:\n",
    "            field_class.append({\"name\": i, \"type\": \"esriFieldTypeString\"})\n",
    "        field_class.append({\"name\": \"input_str\", \"type\": \"esriFieldTypeString\"})\n",
    "        feature_dict = {\n",
    "            \"fields\": field_class,\n",
    "            'geometryType': \"\",\n",
    "            'features':features_list\n",
    "        }\n",
    "        return FeatureSet.from_dict(feature_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad42812c-04b7-45aa-aad5-9cb91b7007d4",
   "metadata": {},
   "source": [
    "#### Key Points:\n",
    "- All of the aforementioned functions must be encapsulated within a class.\n",
    "- The class name should match the Inference Function file name, excluding the file extension.\n",
    "- The author can define helper functions either within the class or in the module.\n",
    "- The author is responsible for handling exceptions.\n",
    "- The input field name must correspond to the name of the input field selected from the input table or feature layer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02d6dab0-352a-4c7c-8e7a-a74aa2178fff",
   "metadata": {},
   "source": [
    "## Custom Deep Learning Package Model File"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "460e5d9c-3dc1-4573-a921-511f50391813",
   "metadata": {},
   "source": [
    "To complete a custom NLP function setup, create a .dlpk model file. \n",
    "\n",
    "Organize the files as follows:\n",
    "\n",
    "**Create a Folder**: Create a folder and include the custom NLP function file. In our case, we will create a folder `NER_gilner_weather`. Inside this, we will place `NER_gilner_weather.emd`, the NLP function file `MyCustomNER.py`, and the directory containing the code of `GLiNER`.\n",
    "\n",
    "\n",
    "  ```      \n",
    "NER_gilner_weather\n",
    "├── MyCustomNER.py\n",
    "├── GLiNER\n",
    "└── NER_gilner_weather.emd\n",
    "\n",
    "```\n",
    "\n",
    "**Zip the Folder**: Create a ZIP archive of the folder. Rename the .zip file to match the name of the ESRI Model Definition (.emd) file but with the .dlpk extension. The ESRI Deep Learning Package (.dlpk) file's name will be `NER_gilner_weather.dlpk`\n",
    "\n",
    "This .dlpk file is now ready for use with the arcgis.learn Python API and Extract Entities Using Deep Learning (GeoAI)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c778a409-0f18-45ae-90b4-21c8db9a86d9",
   "metadata": {},
   "source": [
    "## Using the Custom ESRI Deep Learning Package (.dlpk) file with the arcgis.learn API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "210644e9-1f5a-49b9-b747-e7b3eb792d7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from arcgis.learn.text import EntityRecognizer\n",
    "\n",
    "# Initialize the model with the dlpk\n",
    "model = EntityRecognizer.from_model(r\"Path_to_the_dlpk\\NER_gilner_weather.dlpk\",\n",
    "                                     classes =[\"impacted location\", \"event date\", \"Quantity\", \"property damage\", \"climatic catastropic event\"])\n",
    "\n",
    "# perform the inference\n",
    "model.predict([\"\"\"Category 1 Hurricane Beryl made landfall in Texas on July 8 producing widespread high wind damage,\n",
    "as the storm was restrengthening at landfall. One significant impact were power outages that impacted millions of people for days.\n",
    "Beryl also produced more than 50 tornadoes across eastern Texas, western Louisiana and southern Arkansas.\n",
    "On July 1, Beryl became the earliest Category 5 hurricane and the second Category 5 on record during the month of July in the Atlantic Ocean.\"\"\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "344d552c-a4f2-4171-ae78-d46e938fe6d9",
   "metadata": {},
   "source": [
    "## Tool Interface"
   ]
  },
  {
   "attachments": {
    "827229ff-852c-4cbc-83ab-f33877c92b93.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "ebd47a55-8977-42c4-aec2-a7b58a986243",
   "metadata": {},
   "source": [
    "![image.png](attachment:827229ff-852c-4cbc-83ab-f33877c92b93.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "814ce835-a4c9-49da-b7f3-e8f4a802e387",
   "metadata": {},
   "source": [
    "## Sample Input Table"
   ]
  },
  {
   "attachments": {
    "b78b27b5-6ddb-4a88-9cd4-5034a89598d9.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "b5e368de-5afb-428d-89e5-2488ef8713b6",
   "metadata": {},
   "source": [
    "![image.png](attachment:b78b27b5-6ddb-4a88-9cd4-5034a89598d9.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5413e868-f42c-4f6a-80a8-3934a79197a5",
   "metadata": {},
   "source": [
    "### After Extension File loading"
   ]
  },
  {
   "attachments": {
    "b542bd87-af00-47d5-9961-b77492590822.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "9a11f9b9-7a03-4579-a707-1d58d3871d32",
   "metadata": {},
   "source": [
    "![image.png](attachment:b542bd87-af00-47d5-9961-b77492590822.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de148252-eeda-4caf-9688-90019c070e51",
   "metadata": {},
   "source": [
    "## Sample Output Table"
   ]
  },
  {
   "attachments": {
    "1edcc5f2-5ef4-4aad-91e3-e82015f5e6ec.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "9a9bf9e4-a58d-4ad2-93b3-eff5d4ce8299",
   "metadata": {},
   "source": [
    "![image.png](attachment:1edcc5f2-5ef4-4aad-91e3-e82015f5e6ec.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c0e49c0-7d7f-47f4-973e-59f12970db7b",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df6df6ec-3f14-4653-9c29-4e5cb1fd7366",
   "metadata": {},
   "source": [
    "In this notebook, we have prepared an ESRI Deep Learning Package (.dlpk) file that can leverage a pre-trained model to perform inference in a zero-shot setting."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
